// $ANTLR 3.0.1 F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g 2008-04-16 22:47:37

package de.ghost23.stubcodegenerator.recognize;

import de.ghost23.stubcodegenerator.model.*;
import de.ghost23.util.StringHashMap;


import org.antlr.runtime.*;

public class stubcodegrammarParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "INDENT", "DEDENT", "EQUALS", "STRING", "SLASH", "DOLLAR", "ID", "NEWLINE", "TAB", "BLANKLINE", "CHANGE_INDENT", "DIGIT", "LETTER", "UNDERSCORE", "DASH", "QUOTE", "WS", "'c'", "'i'", "'t'"
    };
    public static final int LETTER=16;
    public static final int DEDENT=5;
    public static final int SLASH=8;
    public static final int WS=20;
    public static final int STRING=7;
    public static final int TAB=12;
    public static final int DOLLAR=9;
    public static final int BLANKLINE=13;
    public static final int QUOTE=19;
    public static final int NEWLINE=11;
    public static final int EQUALS=6;
    public static final int EOF=-1;
    public static final int INDENT=4;
    public static final int DIGIT=15;
    public static final int DASH=18;
    public static final int UNDERSCORE=17;
    public static final int CHANGE_INDENT=14;
    public static final int ID=10;

        public stubcodegrammarParser(TokenStream input) {
            super(input);
        }
        

    public String[] getTokenNames() { return tokenNames; }
    public String getGrammarFileName() { return "F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g"; }


    public static class prog_return extends ParserRuleReturnScope {
        public PackageObj rootPackage;
        public StringHashMap varStatements;
    };

    // $ANTLR start prog
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:28:1: prog returns [PackageObj rootPackage, StringHashMap varStatements] : ( variabledef[$varStatements] )+ s= structure ;
    public final prog_return prog() throws RecognitionException {
        prog_return retval = new prog_return();
        retval.start = input.LT(1);

        PackageObj s = null;


        
        	retval.varStatements = new StringHashMap();

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:32:2: ( ( variabledef[$varStatements] )+ s= structure )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:32:4: ( variabledef[$varStatements] )+ s= structure
            {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:32:4: ( variabledef[$varStatements] )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( ((LA1_0>=DOLLAR && LA1_0<=ID)) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:32:4: variabledef[$varStatements]
            	    {
            	    pushFollow(FOLLOW_variabledef_in_prog72);
            	    variabledef(retval.varStatements);
            	    _fsp--;


            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);

            pushFollow(FOLLOW_structure_in_prog80);
            s=structure();
            _fsp--;

            
            		retval.rootPackage = s;
            	

            }

            retval.stop = input.LT(-1);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end prog


    // $ANTLR start variabledef
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:38:1: variabledef[StringHashMap varStatements] : k= identifier EQUALS STRING ;
    public final void variabledef(StringHashMap varStatements) throws RecognitionException {
        Token STRING1=null;
        identifier_return k = null;


        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:39:2: (k= identifier EQUALS STRING )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:39:4: k= identifier EQUALS STRING
            {
            pushFollow(FOLLOW_identifier_in_variabledef95);
            k=identifier();
            _fsp--;

            match(input,EQUALS,FOLLOW_EQUALS_in_variabledef97); 
            STRING1=(Token)input.LT(1);
            match(input,STRING,FOLLOW_STRING_in_variabledef99); 
            
            		varStatements.put(input.toString(k.start,k.stop), STRING1.getText().substring(1,STRING1.getText().length()-1));
            	

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end variabledef


    // $ANTLR start structure
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:44:1: structure returns [PackageObj parsedObject] : (f= file | asp= aspackage )+ ;
    public final PackageObj structure() throws RecognitionException {
        PackageObj parsedObject = null;

        FileObj f = null;

        PackageObj asp = null;


        
        	parsedObject = new PackageObj();
        	parsedObject.name = "root";

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:49:2: ( (f= file | asp= aspackage )+ )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:49:4: (f= file | asp= aspackage )+
            {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:49:4: (f= file | asp= aspackage )+
            int cnt2=0;
            loop2:
            do {
                int alt2=3;
                int LA2_0 = input.LA(1);

                if ( ((LA2_0>=21 && LA2_0<=22)) ) {
                    alt2=1;
                }
                else if ( (LA2_0==SLASH) ) {
                    alt2=2;
                }


                switch (alt2) {
            	case 1 :
            	    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:49:6: f= file
            	    {
            	    pushFollow(FOLLOW_file_in_structure125);
            	    f=file();
            	    _fsp--;

            	    parsedObject.childFiles.add(f);

            	    }
            	    break;
            	case 2 :
            	    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:50:5: asp= aspackage
            	    {
            	    pushFollow(FOLLOW_aspackage_in_structure135);
            	    asp=aspackage();
            	    _fsp--;

            	    parsedObject.childPackages.add(asp);

            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return parsedObject;
    }
    // $ANTLR end structure


    // $ANTLR start aspackage
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:53:1: aspackage returns [PackageObj parsedObject] : foldername ( INDENT (f= file | asp= aspackage )* ( DEDENT | EOF ) )? ;
    public final PackageObj aspackage() throws RecognitionException {
        PackageObj parsedObject = null;

        FileObj f = null;

        PackageObj asp = null;

        foldername_return foldername2 = null;


        
        	parsedObject = new PackageObj();

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:57:2: ( foldername ( INDENT (f= file | asp= aspackage )* ( DEDENT | EOF ) )? )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:57:4: foldername ( INDENT (f= file | asp= aspackage )* ( DEDENT | EOF ) )?
            {
            pushFollow(FOLLOW_foldername_in_aspackage160);
            foldername2=foldername();
            _fsp--;

            parsedObject.name = input.toString(foldername2.start,foldername2.stop).substring(1);
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:58:3: ( INDENT (f= file | asp= aspackage )* ( DEDENT | EOF ) )?
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==INDENT) ) {
                alt4=1;
            }
            switch (alt4) {
                case 1 :
                    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:59:4: INDENT (f= file | asp= aspackage )* ( DEDENT | EOF )
                    {
                    match(input,INDENT,FOLLOW_INDENT_in_aspackage171); 
                    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:60:4: (f= file | asp= aspackage )*
                    loop3:
                    do {
                        int alt3=3;
                        int LA3_0 = input.LA(1);

                        if ( ((LA3_0>=21 && LA3_0<=22)) ) {
                            alt3=1;
                        }
                        else if ( (LA3_0==SLASH) ) {
                            alt3=2;
                        }


                        switch (alt3) {
                    	case 1 :
                    	    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:60:6: f= file
                    	    {
                    	    pushFollow(FOLLOW_file_in_aspackage180);
                    	    f=file();
                    	    _fsp--;

                    	    parsedObject.childFiles.add(f);

                    	    }
                    	    break;
                    	case 2 :
                    	    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:61:6: asp= aspackage
                    	    {
                    	    pushFollow(FOLLOW_aspackage_in_aspackage191);
                    	    asp=aspackage();
                    	    _fsp--;

                    	    parsedObject.childPackages.add(asp);

                    	    }
                    	    break;

                    	default :
                    	    break loop3;
                        }
                    } while (true);

                    if ( input.LA(1)==EOF||input.LA(1)==DEDENT ) {
                        input.consume();
                        errorRecovery=false;
                    }
                    else {
                        MismatchedSetException mse =
                            new MismatchedSetException(null,input);
                        recoverFromMismatchedSet(input,mse,FOLLOW_set_in_aspackage204);    throw mse;
                    }


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return parsedObject;
    }
    // $ANTLR end aspackage

    public static class foldername_return extends ParserRuleReturnScope {
    };

    // $ANTLR start foldername
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:66:1: foldername : SLASH identifier ;
    public final foldername_return foldername() throws RecognitionException {
        foldername_return retval = new foldername_return();
        retval.start = input.LT(1);

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:67:2: ( SLASH identifier )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:67:4: SLASH identifier
            {
            match(input,SLASH,FOLLOW_SLASH_in_foldername224); 
            pushFollow(FOLLOW_identifier_in_foldername226);
            identifier();
            _fsp--;


            }

            retval.stop = input.LT(-1);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end foldername


    // $ANTLR start file
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:69:1: file returns [FileObj parsedObject] : ( asclass | asinterface ) ( asarguments[$parsedObject] )? ;
    public final FileObj file() throws RecognitionException {
        FileObj parsedObject = null;

        ClassObj asclass3 = null;

        InterfaceObj asinterface4 = null;


        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:70:2: ( ( asclass | asinterface ) ( asarguments[$parsedObject] )? )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:70:4: ( asclass | asinterface ) ( asarguments[$parsedObject] )?
            {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:70:4: ( asclass | asinterface )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==21) ) {
                alt5=1;
            }
            else if ( (LA5_0==22) ) {
                alt5=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("70:4: ( asclass | asinterface )", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:70:6: asclass
                    {
                    pushFollow(FOLLOW_asclass_in_file241);
                    asclass3=asclass();
                    _fsp--;

                    parsedObject = asclass3;

                    }
                    break;
                case 2 :
                    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:71:5: asinterface
                    {
                    pushFollow(FOLLOW_asinterface_in_file249);
                    asinterface4=asinterface();
                    _fsp--;

                    parsedObject = asinterface4;

                    }
                    break;

            }

            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:72:5: ( asarguments[$parsedObject] )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==23) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:72:5: asarguments[$parsedObject]
                    {
                    pushFollow(FOLLOW_asarguments_in_file257);
                    asarguments(parsedObject);
                    _fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return parsedObject;
    }
    // $ANTLR end file


    // $ANTLR start asclass
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:75:1: asclass returns [ClassObj parsedObject] : 'c' identifier ;
    public final ClassObj asclass() throws RecognitionException {
        ClassObj parsedObject = null;

        identifier_return identifier5 = null;


        
        	parsedObject = new ClassObj();

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:79:2: ( 'c' identifier )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:79:4: 'c' identifier
            {
            match(input,21,FOLLOW_21_in_asclass279); 
            pushFollow(FOLLOW_identifier_in_asclass281);
            identifier5=identifier();
            _fsp--;

            parsedObject.name = input.toString(identifier5.start,identifier5.stop);

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return parsedObject;
    }
    // $ANTLR end asclass


    // $ANTLR start asinterface
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:81:1: asinterface returns [InterfaceObj parsedObject] : 'i' identifier ;
    public final InterfaceObj asinterface() throws RecognitionException {
        InterfaceObj parsedObject = null;

        identifier_return identifier6 = null;


        
        	parsedObject = new InterfaceObj();

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:85:2: ( 'i' identifier )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:85:4: 'i' identifier
            {
            match(input,22,FOLLOW_22_in_asinterface301); 
            pushFollow(FOLLOW_identifier_in_asinterface303);
            identifier6=identifier();
            _fsp--;

            parsedObject.name = input.toString(identifier6.start,identifier6.stop);

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return parsedObject;
    }
    // $ANTLR end asinterface


    // $ANTLR start asarguments
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:87:1: asarguments[FileObj parsedObject] : individualTemplate ;
    public final void asarguments(FileObj parsedObject) throws RecognitionException {
        String individualTemplate7 = null;


        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:88:2: ( individualTemplate )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:88:4: individualTemplate
            {
            pushFollow(FOLLOW_individualTemplate_in_asarguments317);
            individualTemplate7=individualTemplate();
            _fsp--;

            parsedObject.template = individualTemplate7;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end asarguments


    // $ANTLR start individualTemplate
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:90:1: individualTemplate returns [String templateName] : 't' STRING ;
    public final String individualTemplate() throws RecognitionException {
        String templateName = null;

        Token STRING8=null;

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:91:2: ( 't' STRING )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:91:4: 't' STRING
            {
            match(input,23,FOLLOW_23_in_individualTemplate332); 
            STRING8=(Token)input.LT(1);
            match(input,STRING,FOLLOW_STRING_in_individualTemplate334); 
            templateName = STRING8.getText().substring(1,STRING8.getText().length()-1);

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return templateName;
    }
    // $ANTLR end individualTemplate

    public static class identifier_return extends ParserRuleReturnScope {
    };

    // $ANTLR start identifier
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:93:1: identifier : ( identifierStart )? identifierPart ;
    public final identifier_return identifier() throws RecognitionException {
        identifier_return retval = new identifier_return();
        retval.start = input.LT(1);

        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:94:2: ( ( identifierStart )? identifierPart )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:94:4: ( identifierStart )? identifierPart
            {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:94:4: ( identifierStart )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==DOLLAR) ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:94:4: identifierStart
                    {
                    pushFollow(FOLLOW_identifierStart_in_identifier345);
                    identifierStart();
                    _fsp--;


                    }
                    break;

            }

            pushFollow(FOLLOW_identifierPart_in_identifier348);
            identifierPart();
            _fsp--;


            }

            retval.stop = input.LT(-1);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end identifier


    // $ANTLR start identifierStart
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:97:1: identifierStart : DOLLAR ;
    public final void identifierStart() throws RecognitionException {
        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:98:2: ( DOLLAR )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:98:4: DOLLAR
            {
            match(input,DOLLAR,FOLLOW_DOLLAR_in_identifierStart359); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end identifierStart


    // $ANTLR start identifierPart
    // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:101:1: identifierPart : ID ;
    public final void identifierPart() throws RecognitionException {
        try {
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:102:2: ( ID )
            // F:\\visual_studio_2008\\StubCodeGenerator\\grammar\\stubcodegrammar.g:102:4: ID
            {
            match(input,ID,FOLLOW_ID_in_identifierPart370); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end identifierPart


 

    public static final BitSet FOLLOW_variabledef_in_prog72 = new BitSet(new long[]{0x0000000000600700L});
    public static final BitSet FOLLOW_structure_in_prog80 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifier_in_variabledef95 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_EQUALS_in_variabledef97 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_STRING_in_variabledef99 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_file_in_structure125 = new BitSet(new long[]{0x0000000000600102L});
    public static final BitSet FOLLOW_aspackage_in_structure135 = new BitSet(new long[]{0x0000000000600102L});
    public static final BitSet FOLLOW_foldername_in_aspackage160 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_INDENT_in_aspackage171 = new BitSet(new long[]{0x0000000000600120L});
    public static final BitSet FOLLOW_file_in_aspackage180 = new BitSet(new long[]{0x0000000000600120L});
    public static final BitSet FOLLOW_aspackage_in_aspackage191 = new BitSet(new long[]{0x0000000000600120L});
    public static final BitSet FOLLOW_set_in_aspackage204 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SLASH_in_foldername224 = new BitSet(new long[]{0x0000000000000600L});
    public static final BitSet FOLLOW_identifier_in_foldername226 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_asclass_in_file241 = new BitSet(new long[]{0x0000000000800002L});
    public static final BitSet FOLLOW_asinterface_in_file249 = new BitSet(new long[]{0x0000000000800002L});
    public static final BitSet FOLLOW_asarguments_in_file257 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_21_in_asclass279 = new BitSet(new long[]{0x0000000000000600L});
    public static final BitSet FOLLOW_identifier_in_asclass281 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_22_in_asinterface301 = new BitSet(new long[]{0x0000000000000600L});
    public static final BitSet FOLLOW_identifier_in_asinterface303 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_individualTemplate_in_asarguments317 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_23_in_individualTemplate332 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_STRING_in_individualTemplate334 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierStart_in_identifier345 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_identifierPart_in_identifier348 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOLLAR_in_identifierStart359 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_identifierPart370 = new BitSet(new long[]{0x0000000000000002L});

}